import java.util.*;

/**
 * 进程类，用于表示每个进程的属性。
 */
class Process {
    String name;        // 进程名
    int arrivalTime;    // 到达时间
    int totalTime;      // 所需运行时间
    int initialPriority;// 初始优先数
    int currentPriority;// 当前优先数
    int remainingTime;  // 剩余运行时间
    int completionTime; // 完成时间
    int index;          // 输入顺序

    public Process(String name, int arrivalTime, int totalTime, int initialPriority, int index) {
        this.name = name;
        this.arrivalTime = arrivalTime;
        this.totalTime = totalTime;
        this.initialPriority = initialPriority;
        this.currentPriority = initialPriority;
        this.remainingTime = totalTime;
        this.completionTime = -1; // 初始化为-1，表示未完成
        this.index = index;
    }
}

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List<Process> processes = new ArrayList<>();

        // 读取4个进程的信息
        for (int i = 0; i < 4; i++) {
            if (!scanner.hasNextLine()) {
                System.err.println("输入不足4行进程信息。");
                return;
            }
            String line = scanner.nextLine().trim();
            if (line.isEmpty()) {
                i--; // 空行不算，重新读取
                continue;
            }
            String[] parts = line.split("\\s+");
            if (parts.length != 4) {
                System.err.println("第" + (i + 1) + "行输入格式错误，应包含4个数据。");
                return;
            }
            String name = parts[0];
            int arrivalTime = Integer.parseInt(parts[1]);
            int totalTime = Integer.parseInt(parts[2]);
            int initialPriority = Integer.parseInt(parts[3]);
            processes.add(new Process(name, arrivalTime, totalTime, initialPriority, i));
        }

        // 变量初始化
        int currentTime = 0;
        int completed = 0;
        int n = processes.size();
        Process runningProcess = null;

        while (completed < n) {
            // 获取当前时间已到达且未完成的所有进程
            List<Process> available = new ArrayList<>();
            for (Process p : processes) {
                if (p.arrivalTime <= currentTime && p.remainingTime > 0) {
                    available.add(p);
                }
            }

            if (available.isEmpty()) {
                // 如果没有进程可执行，时间跳到下一个可能到达的进程
                currentTime++;
                continue;
            }

            // 选择优先数最高的进程，若优先数相同则选择输入顺序靠前的
            available.sort((p1, p2) -> {
                if (p2.currentPriority != p1.currentPriority) {
                    return p2.currentPriority - p1.currentPriority; // 优先数降序
                } else {
                    return p1.index - p2.index; // 输入顺序升序
                }
            });

            Process selected = available.get(0);

            // 运行选中的进程
            selected.remainingTime--;

            // 检查是否完成
            if (selected.remainingTime == 0) {
                selected.completionTime = currentTime + 1;
                completed++;
            }

            // 更新优先数
            // 运行态进程优先数减1
            selected.currentPriority -= 1;

            // 就绪态进程优先数加1
            for (Process p : available) {
                if (p != selected && p.remainingTime > 0) {
                    p.currentPriority += 1;
                }
            }

            // 时间递增
            currentTime++;
        }

        // 根据输入顺序输出完成时间
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            sb.append(processes.get(i).completionTime);
            if (i != n -1) {
                sb.append(" ");
            }
        }
        System.out.println(sb.toString());
    }
}
